home *** CD-ROM | disk | FTP | other *** search
/ Revolution - Das Atari CD Magazin 1997 / Revolution - Das Atari CD Magazin 1.iso / software / anwendng / qed_397 / sourcen / options.c < prev    next >
C/C++ Source or Header  |  1997-01-14  |  33KB  |  1,300 lines
  1. #include "global.h"
  2. #include "av.h"
  3. #include "ausgabe.h"
  4. #include "clipbrd.h"
  5. #include "desktop.h"
  6. #include "disk.h"
  7. #include "edit.h"
  8. #include "error.h"
  9. #include "file.h"
  10. #include "find.h"
  11. #include "fontsel.h"
  12. #include "icon.h"
  13. #include "kurzel.h"
  14. #include "makro.h"
  15. #include "mintlib.h"
  16. #include "obj.h"
  17. #include "printer.h"
  18. #include "projekt.h"
  19. #include "rsc.h"
  20. #include "scroll.h"
  21. #include "se.h"
  22. #include "set.h"
  23. #include "text.h"
  24. #include "version.h"
  25. #include "windows.h"
  26. #include "wp-print.h"
  27.  
  28. #include "options.h"
  29.  
  30. LOCAL WORD    edobj;
  31.  
  32. /*
  33.  * Autosave
  34. */
  35. GLOBAL BOOLEAN as_text, as_proj;
  36. GLOBAL BOOLEAN as_text_ask, as_proj_ask;
  37. GLOBAL WORD     as_text_min, as_proj_min;
  38.  
  39.  
  40. GLOBAL VOID autosave_dial(VOID)
  41. {
  42.     UBYTE    s[10];
  43.     WORD    antw;
  44.  
  45.     select_objc(autosave, ASTEXT, as_text);
  46.     itoa(as_text_min, s, 10);
  47.     objc_setstring(autosave, ASTMIN, s);
  48.     select_objc(autosave, ASTASK, as_text_ask);
  49.  
  50.     select_objc(autosave, ASPROJ, as_proj);
  51.     itoa(as_proj_min, s, 10);
  52.     objc_setstring(autosave, ASPMIN, s);
  53.     select_objc(autosave, ASPASK, as_proj_ask);
  54.  
  55.     Arrow_mouse();
  56.     antw = HndlDial(autosave, 0, FALSE, NULL, NULL);
  57.     Last_mouse();
  58.     if (antw == ASOK)
  59.     {
  60.         as_text = get_select(autosave, ASTEXT);
  61.         objc_getstring(autosave, ASTMIN, s);
  62.         as_text_min = atoi(s);
  63.         if (as_text_min < 1)
  64.             as_text_min = 1;
  65.         if (as_text_min > 59)
  66.             as_text_min = 59;
  67.         as_text_ask = get_select(autosave, ASTASK);
  68.  
  69.         as_proj = get_select(autosave, ASPROJ);
  70.         objc_getstring(autosave, ASPMIN, s);
  71.         as_proj_min = atoi(s);
  72.         if (as_proj_min < 1)
  73.             as_proj_min = 1;
  74.         if (as_proj_min > 59)
  75.             as_proj_min = 59;
  76.         as_proj_ask = get_select(autosave, ASPASK);
  77.  
  78.         do_all_icon(ALL_TYPES, DO_AUTOSAVE);
  79.     }
  80. }
  81.  
  82.  
  83. /*
  84.  * Globale Optionen
  85. */
  86. GLOBAL BOOLEAN        wish_no_desktop, no_desktop;
  87. GLOBAL BOOLEAN        wind_cycle;
  88. GLOBAL WORD            cu_mode, cu_width2, cu_high2, transfer_size;
  89. GLOBAL BOOLEAN        save_opt, cu_icon, cu_window, cu_width, cu_high,
  90.                         overwrite, blinking_cursor, ctrl_mark_mode;
  91. GLOBAL PATH            helpprog;
  92.  
  93.  
  94. LOCAL VOID do_avopen(WINDP window)
  95. {
  96.     if (window->handle != DESK)
  97.         send_avwinopen(window->handle);
  98. }
  99.  
  100. LOCAL VOID do_avclose(WINDP window)
  101. {
  102.     if (window->handle != DESK)
  103.         send_avwinclose(window->handle);
  104. }
  105.  
  106. GLOBAL VOID global_options(VOID)
  107. {
  108.     WORD        antw;
  109.     UBYTE     s[13];
  110.     BOOLEAN    prev_no_desktop, old_cycle, new_cycle, quit = FALSE;
  111.     DIALINFO    dial;
  112.     FSEL        fsel = {"", "*.*"};
  113.     PATH        n = "", newhelpprog;
  114.  
  115.     prev_no_desktop = no_desktop;
  116.     old_cycle = wind_cycle;
  117.     select_objc(globalop, OASAVE, save_opt);
  118.     select_objc(globalop, ONODESK, wish_no_desktop);
  119.     disable_objc(globalop, OCLIP, (scrapdir[0] == EOS));
  120.     select_objc(globalop, OCLIP, is_clip_ondisk());
  121.     select_objc(globalop, OWINDOW, wind_cycle);
  122.     select_objc(globalop, OBLINK, blinking_cursor);
  123.     select_objc(globalop, OEXTFONT, extern_fontselect);
  124.     select_objc(globalop, OCTRL, ctrl_mark_mode);
  125.     itoa(transfer_size,s,10);
  126.     objc_setstring(globalop, OTRANS, s);
  127.     if (helpprog[0] != EOS)
  128.         file_name(helpprog, s, FALSE);
  129.     else
  130.         strcpy(s, "");
  131.     objc_setstring(globalop, OHELPNAME, s);
  132.     strcpy(newhelpprog, helpprog);
  133.  
  134.     Arrow_mouse();
  135.     open_dial(globalop, FALSE, NULL, &dial);
  136.     dial_draw(&dial);
  137.     edobj = OTRANS;
  138.     do
  139.     {
  140.         antw = dial_do(&dial, &edobj) & 0x7FFF;
  141.         switch (antw)
  142.         {
  143.             case OHELP :
  144.                 close_dial(FALSE, NULL, &dial);
  145.                 if (helpprog[0] != EOS)
  146.                 {
  147.                     set_fsel_path(helpprog);
  148.                     file_name(helpprog, n, FALSE);
  149.                 }
  150.                 strcpy(fsel.name, n);
  151.                 if (select_file(&fsel, n, STRING(FINDHPSTR)))
  152.                 {
  153.                     strcpy(newhelpprog, n);
  154.                     file_name(newhelpprog, n, FALSE);
  155.                     objc_setstring(globalop, OHELPNAME, n);
  156.                 }
  157.                 open_dial(globalop, FALSE, NULL, &dial);
  158.                 select_objc(globalop, antw, FALSE);
  159.                 dial_draw(&dial);
  160.                 break;
  161.             default:
  162.                 quit = TRUE;
  163.                 break;
  164.         }
  165.     }
  166.     while (!quit);
  167.     select_objc(globalop, antw, FALSE);
  168.     dial_end(&dial);
  169.     if (antw == GOOK)
  170.     {
  171.         save_opt = get_select(globalop, OASAVE);
  172.         wish_no_desktop = get_select(globalop, ONODESK);
  173.         if (scrapdir[0]!=EOS)
  174.             clip_ondisk(get_select(globalop, OCLIP));
  175.         new_cycle = get_select(globalop, OWINDOW);
  176.         if (old_cycle && !new_cycle)                        /* war an, nun aus */
  177.         {
  178.             get_all_windows(NIL, SRCH_OPENED, do_avclose);
  179.             wind_cycle = new_cycle;
  180.         }
  181.         if (new_cycle && !old_cycle)                        /* nun an, war aus */
  182.         {
  183.             wind_cycle = new_cycle;
  184.             get_all_windows(NIL, SRCH_OPENED, do_avopen);
  185.         }
  186.         blinking_cursor = get_select(globalop, OBLINK);
  187.         extern_fontselect = get_select(globalop, OEXTFONT);
  188.         ctrl_mark_mode = get_select(globalop, OCTRL);
  189.         objc_getstring (globalop, OTRANS, s);
  190.         transfer_size = atoi(s);
  191.         if (transfer_size == 0)
  192.             transfer_size = 1;
  193.         strcpy(helpprog, newhelpprog);
  194.  
  195.         if (prev_no_desktop != wish_no_desktop)
  196.             note(1, DESKCHG);
  197.  
  198.     }
  199.     Last_mouse();
  200. } /* mglobalop */
  201.  
  202.  
  203. /*
  204.  * Lokale Optionen
  205. */
  206. GLOBAL UBYTE        muster_str[MUSTER_ANZ][MUSTER_LEN+1];
  207. GLOBAL LOCAL_OPT    loc_opt[MUSTER_ANZ];
  208. GLOBAL WORD            loc_opt_anz;
  209.  
  210. LOCAL WORD             local_option;
  211. LOCAL BOOLEAN        krz_changed = FALSE;
  212. LOCAL WORD            selected_muster;
  213. LOCAL LOCAL_OPT    bak_loc_opt[MUSTER_ANZ];
  214. LOCAL UBYTE         bak_muster_str[MUSTER_ANZ][MUSTER_LEN+1];
  215.  
  216. LOCAL VOID option_fill(VOID)
  217. {
  218.     UBYTE     s[10], str[13] = "";
  219.     LOC_OPTP lo;
  220.  
  221.     lo = &loc_opt[local_option];
  222.     select_objc(localop, OTAB, lo->tab);
  223.     itoa(lo->tabsize,s,10);
  224.     objc_setstring(localop, OTABSIZE, s);
  225.     select_objc(localop, OEINRUCK, lo->einruecken);
  226.     objc_setstring(localop, OWORT, lo->wort_str);
  227.     select_objc(localop, OUMBRUCH, lo->umbrechen);
  228.     select_objc(localop, OFORMLOAD, lo->format_by_load);
  229.     select_objc(localop, OFORMPASTE, lo->format_by_paste);
  230.     objc_setstring(localop, OUMBTEXT, lo->umbruch_str);
  231.     itoa(lo->lineal_len,s,10);
  232.     select_objc(localop, OBACKUP, lo->backup);
  233.     objc_setstring(localop, OEXT, lo->backup_ext);
  234.     objc_setstring(localop, OLINEAL, s);
  235.     if (lo->kurzel[0] != EOS)
  236.         file_name(lo->kurzel, str, FALSE);
  237.     else
  238.         strcpy(str, STRING(KURZELSTR));
  239.     fill_ptext(localop, OKURZELNAME, str);
  240.     select_objc(localop, OSHOWEND, lo->show_end);
  241. }
  242.  
  243. LOCAL VOID option_get(VOID)
  244. {
  245.     UBYTE     s[20];
  246.     WORD        help;
  247.     LOC_OPTP lo;
  248.  
  249.     lo = &loc_opt[local_option];
  250.     lo->tab = get_select(localop, OTAB);
  251.     objc_getstring (localop, OTABSIZE, s);
  252.     if (*s)
  253.     {
  254.         help = atoi(s);
  255.         if (help < 1 || help > 50)
  256.             help = 3;
  257.     }
  258.     else
  259.         help = 3;
  260.     lo->tabsize = help;
  261.     lo->umbrechen = get_select(localop, OUMBRUCH);
  262.     lo->einruecken = get_select(localop, OEINRUCK);
  263.     objc_getstring(localop, OUMBTEXT, lo->umbruch_str);
  264.     str2set(lo->umbruch_str,lo->umbruch_set);
  265.     lo->format_by_load = get_select(localop, OFORMLOAD);
  266.     lo->format_by_paste = get_select(localop, OFORMPASTE);
  267.     lo->backup = get_select(localop, OBACKUP);
  268.     objc_getstring(localop, OEXT, lo->backup_ext);
  269.     objc_getstring(localop, OLINEAL, s);
  270.     if (*s)
  271.     {
  272.         help = atoi(s);
  273.         if (help < 3 || help > 200) help = 65;
  274.     }
  275.     else
  276.         help = 65;
  277.     lo->lineal_len = help;
  278.     objc_getstring(localop, OWORT, lo->wort_str);
  279.     str2set(lo->wort_str,lo->wort_set);
  280.     lo->show_end = get_select(localop, OSHOWEND);
  281. }
  282.  
  283. LOCAL BOOLEAN option_changed(VOID)
  284. {
  285.     UBYTE     s[40];
  286.     WORD        help;
  287.     LOC_OPTP lo;
  288.  
  289.     lo = &loc_opt[local_option];
  290.     if (lo->tab != get_select(localop, OTAB)) return TRUE;
  291.     objc_getstring (localop, OTABSIZE, s);
  292.     if (*s)
  293.     {
  294.         help = atoi(s);
  295.         if (help<1 || help>50) help = 3;
  296.     }
  297.     else
  298.         help = 3;
  299.     if (lo->tabsize != help)
  300.         return TRUE;
  301.     if (lo->umbrechen != get_select(localop, OUMBRUCH))
  302.         return TRUE;
  303.     if (lo->einruecken != get_select(localop, OEINRUCK))
  304.         return TRUE;
  305.     objc_getstring(localop, OUMBTEXT, s);
  306.     if (strcmp(lo->umbruch_str,s))
  307.         return TRUE;
  308.     str2set(lo->umbruch_str,lo->umbruch_set);
  309.     if (lo->format_by_load != get_select(localop, OFORMLOAD))
  310.         return TRUE;
  311.     if (lo->format_by_paste != get_select(localop, OFORMPASTE))
  312.         return TRUE;
  313.     objc_getstring(localop, OLINEAL, s);
  314.     if (*s)
  315.     {
  316.         help = atoi(s);
  317.         if (help<3 || help>200) help = 65;
  318.     }
  319.     else
  320.         help = 65;
  321.     if (lo->lineal_len != help)
  322.         return TRUE;
  323.     objc_getstring(localop, OWORT, s);
  324.     if (strcmp(lo->wort_str,s))
  325.         return TRUE;
  326.     str2set(lo->wort_str,lo->wort_set);
  327.  
  328.     objc_getstring(localop, OEXT, s);
  329.     if (strcmp(lo->backup_ext, s))
  330.         return TRUE;
  331.     if (lo->backup != get_select(localop, OBACKUP))
  332.         return TRUE;
  333.  
  334.     if (krz_changed)
  335.     {
  336.         krz_changed = FALSE;
  337.         return TRUE;
  338.     }
  339.     if (lo->show_end != get_select(localop, OSHOWEND))
  340.         return TRUE;
  341.     return FALSE;
  342. }
  343.  
  344.  
  345. LOCAL VOID config_muster(VOID)
  346. {
  347.     DIALINFO    dial;
  348.     BOOLEAN    quit = FALSE;
  349.     WORD        i, antw;
  350.     UBYTE     str[MUSTER_LEN+1];
  351.  
  352.     if (option_changed() && note(1,APPLAYCH)==2)
  353.         return;
  354.     option_get();
  355.  
  356.     /* Daten für Abbruch retten */
  357.     COPYW(bak_loc_opt, loc_opt, (short) sizeof(LOCAL_OPT) * MUSTER_ANZ);
  358.     COPYW(bak_muster_str, muster_str, MUSTER_ANZ * (MUSTER_LEN+1));
  359.  
  360.     selected_muster = -1;
  361.     disable_objc(muster, DMDELETE, TRUE);
  362.     disable_objc(muster, DMCHANGE, TRUE);
  363.     disable_objc(muster, DMNEW, (loc_opt_anz == MUSTER_ANZ));
  364.  
  365.     for (i=1; i<loc_opt_anz; i++)
  366.     {
  367.         objc_setstring(muster, DM1 + i - 1, muster_str[i]);
  368.         do_flags(muster, DM1 + i - 1, SELECTABLE);
  369.     }
  370.     for (; i<MUSTER_ANZ; i++)
  371.     {
  372.         objc_setstring(muster,DM1 + i - 1, STRING(FREESTR));
  373.         disable_objc(muster, DM1 + i - 1, TRUE);
  374.     }
  375.  
  376.     open_dial(muster, FALSE, NULL, &dial);
  377.     dial_draw(&dial);
  378.     do
  379.     {
  380.         antw = dial_do(&dial, NULL) & 0x7FFF;
  381.         if (antw >= DM1 && antw <= DM9)
  382.         {
  383.             if (antw == selected_muster)
  384.             {
  385.                 select_objc(muster, selected_muster, FALSE);
  386.                 selected_muster = -1;
  387.                 disable_objc(muster, DMNEW, FALSE);
  388.                 disable_objc(muster, DMDELETE, TRUE);
  389.                 disable_objc(muster, DMCHANGE, TRUE);
  390.             }
  391.             else
  392.             {
  393.                 select_objc(muster, selected_muster, FALSE);
  394.                 selected_muster = antw;
  395.                 select_objc(muster, selected_muster, TRUE);
  396.  
  397.                 disable_objc(muster, DMNEW, TRUE);
  398.                 disable_objc(muster, DMDELETE, FALSE);
  399.                 disable_objc(muster, DMCHANGE, FALSE);
  400.             }
  401.             dial_draw(&dial);
  402.         }
  403.         else
  404.         {
  405.             switch (antw)
  406.             {
  407.                 case DMNEW:                             /* Neues Dateimuster eingeben */
  408.                     objc_setstring(musterchg, DMCTEXT, "");
  409.                     if (HndlDial(musterchg, 0, FALSE, NULL, NULL) == DMCOK)
  410.                     {
  411.                         WORD    i;
  412.  
  413.                         i = loc_opt_anz;
  414.                         if (i < MUSTER_ANZ)
  415.                         {
  416.                             objc_getstring(musterchg, DMCTEXT, str);
  417.                             objc_setstring(muster, DM1 + i - 1, str);
  418.                             disable_objc(muster, DM1 + i - 1, FALSE);
  419.                             strcpy(muster_str[i],str);
  420.                             COPYW(&loc_opt[i], &loc_opt[0], (short) sizeof(LOCAL_OPT));
  421.                             loc_opt_anz++;
  422.                             draw_Objc(muster, DMEXTBOX, 8);
  423.                         }
  424.                     }
  425.                     if (loc_opt_anz == MUSTER_ANZ)        /* wenn voll, Button aus! */
  426.                     {
  427.                         disable_objc(muster, DMNEW, TRUE);
  428.                         draw_Objc(muster, DMNEW, 1);
  429.                     }
  430.                     break;
  431.                 case DMDELETE:                         /* Muster löschen */
  432.                     i = selected_muster - DM1 + 1;
  433.                     if (i == local_option)            /* aktuelles Muster gelöscht! */
  434.                         local_option = 0;
  435.                     COPYW(&loc_opt[i], &loc_opt[i+1], (short) sizeof(LOCAL_OPT) * (loc_opt_anz-i-1));
  436.                     COPYW(&muster_str[i], &muster_str[i+1], (MUSTER_LEN+1) * (loc_opt_anz-i-1));
  437.                     loc_opt_anz--;
  438.                     for (; i<loc_opt_anz; i++)
  439.                         objc_setstring(muster, DM1 + i - 1, muster_str[i]);
  440.  
  441.                     if (i < MUSTER_ANZ)
  442.                     {
  443.                             objc_setstring(muster, DM1 + i - 1, STRING(FREESTR));
  444.                             disable_objc(muster, DM1 + i - 1, TRUE);
  445.                     }
  446.                     select_objc(muster, selected_muster, FALSE);
  447.  
  448.                     selected_muster = -1;
  449.                     disable_objc(muster, DMDELETE, TRUE);
  450.                     disable_objc(muster, DMCHANGE, TRUE);
  451.  
  452.                     if (loc_opt_anz < MUSTER_ANZ)         /* wieder welche frei? */
  453.                         disable_objc(muster, DMNEW, FALSE);
  454.  
  455.                     dial_draw(&dial);
  456.                     break;
  457.                 case DMCHANGE:                         /* Muster ändern */
  458.                     objc_getstring(muster, selected_muster, str);
  459.                     objc_setstring(musterchg, DMCTEXT, str);
  460.                     if (HndlDial(musterchg, 0, FALSE, NULL, NULL) == DMCOK)
  461.                     {
  462.                         objc_getstring(musterchg, DMCTEXT, str);
  463.                         objc_setstring(muster, selected_muster, str);
  464.                         draw_Objc(muster, DMEXTBOX, 8);
  465.                         strcpy(muster_str[selected_muster - DM1 + 1], str);
  466.                     }
  467.                     break;
  468.                 default:
  469.                     quit = TRUE;
  470.                     break;
  471.             } /* switch */
  472.             select_objc(muster, antw, FALSE);
  473.             draw_Objc(muster, antw, 1);
  474.         } /* if */
  475.     } /* while */
  476.     while (!quit);
  477.     dial_end(&dial);
  478.     disable_objc(localop, OTYPECIRC, (loc_opt_anz <= 1));
  479.     if (antw == DMOK)
  480.     {
  481.         if (muster_str[local_option][0]==EOS)
  482.         {
  483.             local_option = 0;
  484.             option_fill();
  485.         }
  486.         draw_Objc(localop, OTYPE, 1);
  487.         draw_Objc(localop, OBOX, 8);
  488.     }
  489.     else
  490.     {
  491.         COPYW(loc_opt,bak_loc_opt, (short) sizeof(LOCAL_OPT) * MUSTER_ANZ);
  492.         COPYW(muster_str, bak_muster_str, MUSTER_ANZ * (MUSTER_LEN + 1));
  493.     }
  494.     if (selected_muster!=-1)
  495.         select_objc(muster, selected_muster, FALSE);
  496. }
  497.  
  498.  
  499. LOCAL BOOLEAN build_popup(POPUP_STRUK *pop)
  500. {
  501.     UBYTE str[MUSTER_LEN + 1];
  502.     WORD    i;
  503.  
  504.     if (loc_opt_anz <= 1)
  505.         return FALSE;
  506.  
  507.     strcpy(str, " ");
  508.     strcat(str, muster_str[0]);
  509.     for (i = (WORD)strlen(str); i < MUSTER_LEN; i++)
  510.         strcat(str, " ");
  511.     create_popup(pop, MUSTER_ANZ, POPUPSTRG, str);
  512.     for (i = 1; i < loc_opt_anz; i++)
  513.     {
  514.         strcpy(str, " ");
  515.         strcat(str, muster_str[i]);
  516.         append_popup(pop, POPUPSTRG, str);
  517.     }
  518.     if (pop->tree != NULL)
  519.     {
  520.         for(i = 0; i < pop->akt_item + 2; i++)
  521.             xrsrc_obfix(pop->tree, i);
  522.         dial_fix(pop->tree);
  523.         return TRUE;
  524.     }
  525.     return FALSE;
  526. }
  527.  
  528.  
  529. GLOBAL VOID local_options(VOID)
  530. {
  531.     WORD            antw, y;
  532.     WINDP         window;
  533.     PATH            save_name;
  534.     DIALINFO        dial;
  535.     BOOLEAN        quit = FALSE, doppel_klick;
  536.     FSEL            fsel = {"", "*.KRZ"};
  537.     PATH            name = "";
  538.     UBYTE         str[MUSTER_LEN + 1] = " ";
  539.     POPUP_STRUK    pop;
  540.  
  541.     local_option = 0;
  542.     window = top();
  543.     if (window->flags & WI_FONTSIZE)
  544.     {
  545.         TEXTP t_ptr = get_text(window->link);
  546.         local_option = (short)(t_ptr->loc_opt - loc_opt);
  547.         strcat(str, muster_str[local_option]);
  548.     }
  549.  
  550.     /* Sonderbehandlung für '*'-Eintrag, damit das Popup klappt! */
  551.     if (local_option == 0)
  552.         strcpy(str, " *             ");
  553.  
  554.     objc_setstring(localop, OTYPE, str);
  555.     option_fill();
  556.     strcpy(save_name, loc_opt[local_option].kurzel);
  557.     disable_objc(localop, OTYPECIRC, (loc_opt_anz <= 1));
  558.  
  559.     Arrow_mouse();
  560.     open_dial(localop, FALSE, NULL, &dial);
  561.     dial_draw(&dial);
  562.     do
  563.     {
  564.         antw = dial_do(&dial, NULL);
  565.         doppel_klick = (antw&0x8000);
  566.         antw &= 0x7FFF;
  567.         switch (antw)
  568.         {
  569.             case OTYPESTR :
  570.             case OTYPECIRC :
  571.             case OTYPE :
  572.                 if (doppel_klick && antw == OTYPE)
  573.                 {
  574.                     config_muster();
  575.                     option_fill();
  576.                     dial_draw(&dial);
  577.                 }
  578.                 else if (build_popup(&pop))
  579.                 {
  580.                     if (antw == OTYPECIRC)
  581.                         y = popup_select(NIL, localop, OTYPE, pop.tree, 1, FALSE, DO_CYCLE, NULL, (POP_CB)NULL);
  582.                     else
  583.                         y = popup_select(NIL, localop, OTYPE, pop.tree, 1, FALSE, DO_POPUP, NULL, (POP_CB)NULL);
  584.                     y -= pop.first_item;
  585.                     if (y >= 0 && y != local_option)
  586.                     {
  587.                         if (option_changed() && note(1,APPLAYCH) == 1)
  588.                                 option_get();
  589.                         local_option = y;
  590.                         option_fill();
  591.                         draw_Objc(localop, OBOX, MAX_DEPTH);
  592.                     }
  593.                     free_popup(&pop);
  594.                 }
  595.                 break;
  596.             case OKURZEL:
  597.                 if (doppel_klick)
  598.                 {
  599.                     strcpy(loc_opt[local_option].kurzel, "");
  600.                     krz_changed = TRUE;
  601.                     fill_ptext(localop, OKURZELNAME, STRING(KURZELSTR));
  602.                     draw_Objc(localop, OKURZELNAME, 1);
  603.                 }
  604.                 else
  605.                 {
  606.                     close_dial(FALSE, NULL, &dial);
  607.                     if (loc_opt[local_option].kurzel[0] != EOS)
  608.                     {
  609.                         set_fsel_path(loc_opt[local_option].kurzel);
  610.                         file_name(loc_opt[local_option].kurzel, name, FALSE);
  611.                     }
  612.                     strcpy(fsel.name, name);
  613.                     if (select_file(&fsel, name, STRING(FINDKURZELSTR)))
  614.                     {
  615.                         strcpy(loc_opt[local_option].kurzel, name);
  616.                         file_name(name, str, FALSE);
  617.                         krz_changed = TRUE;
  618.                         objc_setstring(localop, OKURZELNAME, str);
  619.                     }
  620.                     open_dial(localop, FALSE, NULL, &dial);
  621.                     select_objc(localop, OKURZEL, FALSE);
  622.                     dial_draw(&dial);
  623.                 }
  624.                 break;
  625.             case OOK:
  626.                 quit = TRUE;
  627.                 break;
  628.             case ORAUS :
  629.                 quit = TRUE;
  630.                 break;
  631.         }
  632.         select_objc(localop, antw, FALSE);
  633.         draw_Objc(localop, antw, 1);
  634.     }
  635.     while (!quit);
  636.     dial_end(&dial);
  637.     if (antw == OOK)
  638.     {
  639.         option_get();
  640.         update_loc_opt();
  641.         absatz_edit();
  642.         ch_kurzel(loc_opt[local_option].kurzel, TRUE);
  643.     }
  644.     else
  645.         strcpy(loc_opt[local_option].kurzel, save_name);
  646.     Last_mouse();
  647. } /* local_option */
  648.  
  649.  
  650. /*
  651.  * Defaulteinstellungen
  652. */
  653. VOID init_default_var(VOID)
  654. {
  655.     WORD         i;
  656.     time_t    t;
  657.  
  658.     s_grkl     = FALSE;
  659.     s_runter      = TRUE;
  660.     s_global      = TRUE;
  661.     s_quant    = FALSE;
  662.     s_wort      = FALSE;
  663.     s_round      = FALSE;
  664.     df_rekursiv= FALSE;
  665.     r_modus      = RP_FIRST;
  666.     s_str[0] = EOS;
  667.     r_str[0] = EOS;
  668.     df_name[0] = EOS;
  669.     for (i = HIST_ANZ; (--i)>=0; s_history[i][0]=EOS)
  670.         ;
  671.     rp_box_x      = 0;
  672.     rp_box_y      = 0;
  673.  
  674.     cu_window  = FALSE;
  675.     cu_icon      = FALSE;
  676.     cu_width      = FALSE;
  677.     cu_high      = FALSE;
  678.     cu_mode      = 0;
  679.     cu_width2  = 80;
  680.     cu_high2   = 20;
  681.  
  682.     use_gdos_print = FALSE;
  683.     vorschub      = TRUE;
  684.     zeilen_nr  = FALSE;
  685.     seiten_nr  = FALSE;
  686.     rand_len   = 2;
  687.     use_rand   = TRUE;
  688.     print_block = 0;
  689.     wp_mode = PICA;
  690.     wp_treiber[0] = EOS;
  691.     wp_nlq = FALSE;
  692.     wp_seiten_len = 65;
  693.     wp_seiten_width = 80;
  694.     metafile[0] = EOS;
  695.  
  696.     save_opt      = FALSE;
  697.     wind_cycle = FALSE;
  698.     clip_ondisk(FALSE);
  699.     wish_no_desktop = no_desktop = FALSE;
  700.     overwrite  = FALSE;
  701.     transfer_size = 100;
  702.     helpprog[0] = EOS;
  703.     blinking_cursor = FALSE;
  704.     extern_fontselect = FALSE;
  705.     ctrl_mark_mode = FALSE;
  706.     for (i = 0; i < 3; i++)
  707.         error[i][0] = EOS;
  708.  
  709.     for (i=MUSTER_ANZ; (--i)>=1; muster_str[i][0]=EOS) ;
  710.     strcpy(muster_str[0],"*");                        /* Bleibt konstant */
  711.     loc_opt[0].tab        = TRUE;
  712.     loc_opt[0].tabsize    = 3;
  713.     loc_opt[0].einruecken = TRUE;
  714.     strcpy(loc_opt[0].wort_str,"A-Za-zäöüßÄÖÜ0-9");
  715.     str2set(loc_opt[0].wort_str,loc_opt[0].wort_set);
  716.     loc_opt[0].umbrechen  = FALSE;
  717.     loc_opt[0].format_by_load = FALSE;
  718.     loc_opt[0].format_by_paste = FALSE;
  719.     strcpy(loc_opt[0].umbruch_str,"- \t");
  720.     str2set(loc_opt[0].umbruch_str,loc_opt[0].umbruch_set);
  721.     loc_opt[0].lineal_len = 70;
  722.     loc_opt_anz = 1;
  723.     strcpy(loc_opt[0].backup_ext, "BAK");
  724.     loc_opt[0].backup = FALSE;
  725.     loc_opt[0].show_end = FALSE;
  726.  
  727.     se_autosave = FALSE;
  728.     se_autosearch = FALSE;
  729.     for (i = 0; i < SHELLANZ; i++)
  730.     {
  731.         se_shells[i].Name[0] = EOS;
  732.         se_shells[i].Makefile[0] = EOS;
  733.     }
  734.  
  735.     umlaut_from = 0;
  736.     umlaut_to = 0;
  737.  
  738.     as_text         = FALSE;
  739.     as_text_min = 0;
  740.     as_text_ask = FALSE;
  741.     as_proj         = FALSE;
  742.     as_proj_min = 0;
  743.     as_proj_ask = FALSE;
  744.  
  745.     time(&t);
  746.     local_time = localtime(&t);
  747.  
  748. }
  749.  
  750.  
  751. /*
  752.  * Datei
  753. */
  754. LOCAL FSEL    qed_fsel = {"DEFAULT.QED","*.QED"};
  755. LOCAL RING    tmp_ring;
  756.  
  757. LOCAL VOID read_opt(const UBYTE *format, UBYTE *str, ...)
  758. {
  759.     va_list    ptr;
  760.     WORD        *i;
  761.     LONG        *l;
  762.     UBYTE        *s;
  763.  
  764.     va_start(ptr,str);
  765.     s = strchr(str,'@');
  766.     while(*format!=EOS)
  767.     {
  768.         if (s==NULL)
  769.         {
  770.             switch (*format++)
  771.             {
  772.                 case 'i':    i = va_arg(ptr,WORD*);
  773.                                 *i = 0;
  774.                                 break;
  775.                 case 'l':    l = va_arg(ptr,LONG*);
  776.                                 *l = 0L;
  777.                                 break;
  778.                 case 's':    strcpy(va_arg(ptr,UBYTE*),"");
  779.                                 break;
  780.             }
  781.         }
  782.         else
  783.         {
  784.             str = s+1;
  785.             s = strchr(str,'@');
  786.             if (s!=NULL) *s = EOS;
  787.             switch (*format++)
  788.             {
  789.                 case 'i':    i = va_arg(ptr,WORD*);
  790.                                 *i = atoi(str);
  791.                                 break;
  792.                 case 'l':    l = va_arg(ptr,LONG*);
  793.                                 *l = atol(str);
  794.                                 break;
  795.                 case 's':    strcpy(va_arg(ptr,UBYTE*),str);
  796.                                 break;
  797.             }
  798.         }
  799.     }
  800.     va_end(ptr);
  801. }
  802.  
  803.  
  804. GLOBAL WORD    option_load    (VOID)
  805. {
  806.     LineEnding    ending;
  807.     RING            t;
  808.  
  809.     if (qed_path[0]==EOS)
  810.     {
  811.         PATH    name;
  812.  
  813.         if (!select_file (&qed_fsel, name, STRING(LOADSETUPSTR)))
  814.         {
  815.             init_default_var();
  816.             return 0;
  817.         }
  818.         make_ext(name, "qed");
  819.         strcpy(qed_path, name);
  820.     }
  821.     else
  822.         file_name(qed_path, qed_fsel.name, FALSE);
  823.  
  824.     init_textring(&t);
  825.  
  826.     if (load_datei(qed_path, &t, FALSE, &ending) == 0)
  827.     {
  828.         LOC_OPTP    lo;
  829.         WORD        opt, opt2, i, l, x, y, version, muster_nr;
  830.         BOOLEAN    bool, out_of_date;
  831.         RECT        r;
  832.         LONG        anz, line;
  833.         LINEP        lauf;
  834.         UBYTE        *str, s[40], s2[40], s3[40], s4[40], *c;
  835.         PATH        p;
  836.         CICONBLK    *cicon;
  837.  
  838.         Busy_mouse();
  839.         muster_nr = 0;
  840.         anz = 0;
  841.         lauf = FIRST(&t);
  842.         str = TEXT(lauf);
  843.         if (*str++ == '#' && *str ++ == 'V')
  844.         {
  845.             read_opt("si", str, s, &version);
  846.  
  847.             out_of_date = (version < ParameterVersion);
  848.             if ((strcmp(s, "qed.INF") == 0))
  849.             {
  850.                 NEXT(lauf);
  851.                 anz = t.lines-1;
  852.             }
  853.         }
  854.         if ((out_of_date) || (anz <= 0))
  855.         {
  856.             i = note(1, WRONGINF);
  857.             if (i == 1)
  858.             {
  859.                 init_default_var();
  860.                 Last_mouse();
  861.                 return 0;
  862.             }
  863.         }
  864.  
  865.         while ((--anz) >= 0)
  866.         {
  867.             if (lauf->len > 3 && TEXT(lauf)[0] == '#')
  868.             {
  869.                 str = TEXT(lauf) + 1;
  870.                 switch(*str++)
  871.                 {
  872.                     case 'A' :
  873.                         read_opt("iiiiii", str,
  874.                                                  &as_text, &as_text_min, &as_text_ask,
  875.                                                    &as_proj, &as_proj_min, &as_proj_ask);
  876.                         break;
  877.                     case 'D' :
  878.                         read_opt("iiiiiiss", str, &opt, &rand_len, &gdos_device, &wp_seiten_len,
  879.                                                          &wp_seiten_width, &wp_mode, wp_treiber, metafile);
  880.                         zeilen_nr = (opt & 1);        opt >>= 1;
  881.                         seiten_nr = (opt & 1);        opt >>= 1;
  882.                         vorschub     = (opt & 1);        opt >>= 1;
  883.                         pruef_prn = (opt & 1);        opt >>= 1;
  884.                         use_rand  = (opt & 1);        opt >>= 1;
  885.                         use_gdos_print= (opt & 1);    opt >>= 1;
  886.                         wp_nlq    = (opt & 1);        opt >>= 1;
  887.                         break;
  888.                     case 'F' :
  889.                         set_makro_str(str + 1);
  890.                         break;
  891.                     case 'G' :
  892.                         read_opt("iiiii",str, &opt, &cu_mode, &cu_width2, &cu_high2,
  893.                                                         &transfer_size);
  894.                         if (transfer_size == 0)
  895.                             transfer_size = 100;
  896.                         save_opt  = (opt & 1);                opt >>= 1;
  897.                         no_desktop= (opt & 1);                opt >>= 1;
  898.                         wish_no_desktop = no_desktop;
  899.                         clip_ondisk((opt & 1));                opt >>= 1;
  900.                         wind_cycle= (opt & 1);                opt >>= 1;
  901.                         blinking_cursor = (opt & 1);        opt >>= 1;
  902.                         extern_fontselect = (opt & 1);    opt >>= 1;
  903.                         overwrite = (opt & 1);                opt >>= 1;
  904.                         cu_icon    = (opt & 1);                opt >>= 1;
  905.                         cu_window = (opt & 1);                opt >>= 1;
  906.                         cu_width  = (opt & 1);                opt >>= 1;
  907.                         cu_high   = (opt & 1);                opt >>= 1;
  908.                         ctrl_mark_mode = (opt & 1);        opt >>= 1;
  909.                         /* frei    opt >>= 1; */
  910.                         /* frei    opt >>= 1; */
  911.                         /* frei    opt >>= 1; */
  912.                         /* frei    opt >>= 1; */
  913.                         break;
  914.                     case 'H' :
  915.                         read_opt("s", str, s);
  916.                         for (i = 0; i < HIST_ANZ; i++)
  917.                             if (s_history[i][0] == EOS)
  918.                                 break;
  919.                             if (i < HIST_ANZ)
  920.                                 strcpy(s_history[i], s);
  921.                         break;
  922.                     case 'I' :
  923.                         read_opt("iii",str, &i, &x, &y);
  924.                         switch (i)
  925.                         {
  926.                             case 0 :     /* F-Tasten */
  927.                                 add_icon_to_desk(0, NULL, x, y);
  928.                                 break;
  929.                             case 2 :     /* PRINTER */
  930.                                 cicon = (CICONBLK *)get_obspec(icons, IPRINTER);
  931.                                 iprinter = add_icon_to_desk(IPRINTER, cicon->monoblk.ib_ptext, x, y);
  932.                                 add_icon(printer_type, iprinter);
  933.                                 break;
  934.                             case 3 :     /* DISK */
  935.                                 cicon = (CICONBLK *)get_obspec(icons, IDISK);
  936.                                 idisk = add_icon_to_desk(IDISK, cicon->monoblk.ib_ptext, x, y);
  937.                                 add_icon(disk_type, idisk);
  938.                                 break;
  939.                         }
  940.                         break;
  941.                     case 'L' :
  942.                         read_opt("siiissss",str, s, &opt, &i, &l, s2, s3, p, s4);
  943.                         if (muster_nr < MUSTER_ANZ)
  944.                         {
  945.                             if (muster_nr > 0)
  946.                                 strcpy(muster_str[muster_nr], s);
  947.                             lo = &loc_opt[muster_nr];
  948.                             lo->tab = (opt & 1);                    opt >>= 1;
  949.                             lo->einruecken = (opt & 1);        opt >>= 1;
  950.                             lo->umbrechen = (opt & 1);            opt >>= 1;
  951.                             lo->format_by_load = (opt & 1);    opt >>= 1;
  952.                             lo->format_by_paste = (opt & 1);    opt >>= 1;
  953.                             lo->backup = (opt & 1);                opt >>= 1;
  954.                             lo->show_end = (opt & 1);            opt >>= 1;
  955.                             lo->tabsize = i;
  956.                             lo->lineal_len = l;
  957.                             strcpy(lo->umbruch_str, s2);
  958.                             str2set(lo->umbruch_str, lo->umbruch_set);
  959.                             strcpy(lo->wort_str, s3);
  960.                             str2set(lo->wort_str,lo->wort_set);
  961.                             strcpy(lo->kurzel, p);
  962.                             strcpy(lo->backup_ext, s4);
  963.                             muster_nr++;
  964.                         }
  965.                         break;
  966.                     case 'M' :
  967.                         read_opt("issli",str, &i, s, p, &line, &x);
  968.                         set_marke(i, s, p, line, x);
  969.                         break;
  970.                     case 'O' :
  971.                         read_opt("s", str, p);
  972.                         add_diskinfo(p, TRUE);
  973.                         break;
  974.                     case 'P' :
  975.                         read_opt("sssss", str, helpprog, error[0], def_prj_path, error[1], error[2]);
  976.                         c = getenv("STGUIDE");
  977.                         if ((helpprog[0] == EOS) && (c != NULL))
  978.                             strcpy(helpprog, c);
  979.                         set_def_prj();
  980.                         break;
  981.                     case 'R' :
  982.                         read_opt("iisssiiii", str, &opt, &r_modus, s_str, r_str, df_name, 
  983.                                                      ¨aut_from, ¨aut_to, &rp_box_x, &rp_box_y);
  984.                         s_round   = (opt & 1);        opt >>= 1;
  985.                         s_quant   = (opt & 1);        opt >>= 1;
  986.                         s_grkl    = (opt & 1);        opt >>= 1;
  987.                         s_runter  = (opt & 1);        opt >>= 1;
  988.                         s_global  = (opt & 1);        opt >>= 1;
  989.                         df_rekursiv = (opt & 1);    opt >>= 1;
  990.                         s_wort     = (opt & 1);        opt >>= 1;
  991.                         break;
  992.                     case 'S' :
  993.                         read_opt("isiis", str, &i, s, &opt, &opt2, p);
  994.                         strcpy(se_shells[i].Name, s);
  995.                         strcpy(se_shells[i].Makefile, p);
  996.                         se_autosave = (opt == 1);
  997.                         se_autosearch = (opt2 == 1);
  998. /*
  999.                         SE_Shells[i].aktiv = (opt == 1);
  1000.                         SE_Shells[i].start_comm = (opt2 == 1);
  1001. */
  1002.                         break;
  1003.                     case 'W' :
  1004.                         read_opt("iiiiiiii", str, &i, &r.x, &r.y, &r.w, &r.h, &opt, &opt2, &bool);
  1005.                         add_windinfo(i, &r, opt, opt2, bool);
  1006.                         break;
  1007.                     case 'Z' :
  1008.                         read_opt("iiii",str, &winFont.ID, &winFont.Size, &druckFont.ID, &druckFont.Size);
  1009.                         font_change();
  1010.                         break;
  1011.                 }
  1012.             }
  1013.             NEXT(lauf);
  1014.         }
  1015.         loc_opt_anz = max(1, muster_nr);
  1016.         kill_textring(&t);
  1017.         Last_mouse();
  1018.         return 0;
  1019.     }
  1020.     else
  1021.     {
  1022.         kill_textring(&t);
  1023.         return 1;
  1024.     }
  1025. }
  1026.  
  1027.  
  1028. LOCAL VOID write_opt(UBYTE* format, ...)
  1029. {
  1030.     UBYTE     str[200], help[20];
  1031.     va_list    ptr;
  1032.     LINEP        col;
  1033.  
  1034.     va_start(ptr,format);
  1035.     str[0] = '#';
  1036.     str[1] = *format++;
  1037.     str[2] = EOS;
  1038.     while(*format!=EOS)
  1039.     {
  1040.         strcat(str,"@");
  1041.         switch(*format++)
  1042.         {
  1043.             case 'i'    :    itoa(va_arg(ptr,WORD),help,10);
  1044.                             strcat(str,help);
  1045.                             break;
  1046.             case 'l' :    ltoa(va_arg(ptr,LONG),help,10);
  1047.                             strcat(str,help);
  1048.                             break;
  1049.             case 's' :    strcat(str,va_arg(ptr,UBYTE*));
  1050.                             break;
  1051.         }
  1052.     }
  1053.     va_end(ptr);
  1054.  
  1055.     col = new_col_w(str, (short)strlen(str));
  1056.     col_append(&tmp_ring, col);
  1057. }
  1058.  
  1059.  
  1060. LOCAL VOID get_wind_data(WINDP window)
  1061. {
  1062.     if (window->flags & WI_ICONIFIED)
  1063.         uniconify_window(window, NULL);
  1064.  
  1065.     if (window->class == CLASS_CLIP)
  1066.     {
  1067.         if (window->opened)
  1068.             write_opt("Os", "-C");
  1069.     }
  1070.     if (window->class == CLASS_EDIT || window->class == CLASS_PROJEKT)
  1071.     {
  1072.         TEXTP        t_ptr = get_text(window->link);
  1073.         UBYTE        str[256], str2[256];
  1074.         WORD        i, j;
  1075.         BOOLEAN    quoting = FALSE;
  1076.  
  1077.         if (!t_ptr->namenlos)
  1078.         {
  1079.             i = 0;
  1080.             j = 0;
  1081.             while (i < strlen(t_ptr->filename))
  1082.             {
  1083.                 str[j++] = t_ptr->filename[i];
  1084.                 if (t_ptr->filename[i] == '\'')            /* gibts ' im Namen? */
  1085.                 {
  1086.                     str[j++] = '\'';
  1087.                     quoting = TRUE;
  1088.                 }
  1089.                 if (t_ptr->filename[i] == ' ')            /* oder Blank? */
  1090.                     quoting = TRUE;
  1091.                 i++;
  1092.             }
  1093.             str[j] = EOS;
  1094.             if (quoting)
  1095.                 sprintf(str2, "\'%s\'", str);
  1096.             else
  1097.                 strcpy(str2, str);
  1098.             strcat(str2," ");
  1099.             ltoa(t_ptr->ypos + 1, str, 10);
  1100.             strcat(str2, str);
  1101.             strcat(str2, " ");
  1102.             ltoa(BildPos(t_ptr->xpos,t_ptr->cursor_line,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize)+1, str, 10);
  1103.             strcat(str2, str);
  1104.             /*
  1105.              * Als Text geöffnete Projekte:
  1106.              */
  1107.             if (window->class == CLASS_EDIT && filematch(t_ptr->filename, "*.QPJ"))
  1108.                 strcat(str2, " -p ");
  1109.             if (!window->opened)
  1110.                 strcat(str2," -o");
  1111.             write_opt("Os", str2);
  1112.         }
  1113.     }
  1114. }
  1115.  
  1116.  
  1117. GLOBAL WORD option_save(BOOLEAN interactiv)
  1118. {
  1119.     LOC_OPTP    lo;
  1120.     LONG        line;
  1121.     WORD        x, y, i, d, opt, opt2;
  1122.     PATH        file;
  1123.     WORD        used, antw;
  1124.     RECT        r;
  1125.     UBYTE        str[256], *p;
  1126.     FILENAME    name;
  1127.  
  1128.     if (interactiv)
  1129.     {
  1130.         if (qed_path[0] == EOS)
  1131.             get_path(qed_path, 0);
  1132.         if (caseSens(qed_path, NULL))
  1133.             strcpy(qed_fsel.suffix, "*.qed");
  1134.         else
  1135.             strcpy(qed_fsel.suffix, "*.QED");
  1136.         set_fsel_path(qed_path);
  1137.         if (!select_file (&qed_fsel, file, STRING(SAVESETUPSTR)))
  1138.             return 0;
  1139.         p = strrchr(file, '.');
  1140.         if ((p == NULL) || ((strcmp(p+1, "qed") != 0) && (strcmp(p+1, "QED") != 0)))
  1141.             make_ext(file, "qed");
  1142.         strcpy(qed_path, file);
  1143.     }
  1144.  
  1145.     init_textring(&tmp_ring);
  1146.  
  1147.     /*
  1148.      * Bisher vergebene Zeilen-Kennungen (3.70) :
  1149.      *
  1150.      *        A    Autosave
  1151.      *        D    Druckerparameter
  1152.      *        F    Funktionstasten
  1153.      *        G    globale Parameter
  1154.      *        H    History Suchbegriffe
  1155.      *        I    Standard-Icons
  1156.      *        L    Lokale Parameter
  1157.      *        M    Marken
  1158.      *        O    Offene Dateien
  1159.      *        P    Diverse Pfade und Texte
  1160.      *        R    Suchen/Ersetzen
  1161.      *        S    SE-Protokoll
  1162.      *        V    Versionsnummer
  1163.      *        W    Fensterpositionen
  1164.      *        Z    Zeichensätze
  1165.      */
  1166.  
  1167.     /* Version */
  1168.     write_opt("Vsi", "qed.INF", ParameterVersion);
  1169.  
  1170.     /* Autosave */
  1171.     write_opt("Aiiiiii", as_text, as_text_min, as_text_ask,
  1172.                                 as_proj, as_proj_min, as_proj_ask);
  1173.  
  1174.     /* Drucker */
  1175.     opt = 0;
  1176.     if (zeilen_nr)            opt += 1;
  1177.     if (seiten_nr)            opt += 2;
  1178.     if (vorschub)            opt += 4;
  1179.     if (pruef_prn)            opt += 8;
  1180.     if    (use_rand)            opt += 16;
  1181.     if (use_gdos_print)    opt += 32;
  1182.     if (wp_nlq)                opt += 64;
  1183.     write_opt("Diiiiiiss", opt, rand_len, gdos_device, wp_seiten_len, wp_seiten_width,
  1184.                                  wp_mode, wp_treiber, metafile);
  1185.  
  1186.     /* Funktionstasten */
  1187.     i = -1;
  1188.     while(get_makro_str(&i, str))
  1189.         write_opt("Fs", str);
  1190.  
  1191.     /* Globales */
  1192.     opt = 0;
  1193.     if (save_opt)                opt += 1;
  1194.     if (wish_no_desktop)        opt += 2;
  1195.     if (is_clip_ondisk())    opt += 4;
  1196.     if (wind_cycle)            opt += 8;
  1197.     if (blinking_cursor)     opt += 16;
  1198.     if (extern_fontselect)    opt += 32;
  1199.  
  1200.     if (overwrite)             opt += 64;            /* Schreibmodus */
  1201.     if (cu_icon)                opt += 128;            /* Aufräumen */
  1202.     if (cu_window)             opt += 256;
  1203.     if (cu_width)                opt += 512;
  1204.     if (cu_high)                opt += 1024;
  1205.     if (ctrl_mark_mode)        opt += 2048;
  1206.     /* frei    opt += 4096; */
  1207.     /* frei    opt += 8192; */
  1208.     /* frei    opt += 16384: */
  1209.     /* frei    opt += 32768; */
  1210.     write_opt("Giiiii", opt, cu_mode, cu_width2, cu_high2, transfer_size);
  1211.  
  1212.     /* History Suchbegriffe */
  1213.     for (i=0; i<HIST_ANZ; i++)
  1214.     {
  1215.         if (s_history[i][0]==EOS) break;
  1216.         write_opt("Hs", s_history[i]);
  1217.     }
  1218.  
  1219.     /* Icons ohne Fenster */
  1220.     get_icon_pos(idisk, &x, &y);
  1221.     write_opt("Iiii", 3, x, y);
  1222.     get_icon_pos(iprinter, &x, &y);
  1223.     write_opt("Iiii", 2, x, y);
  1224.     get_icon_pos(0, &x, &y);                /* F-Tasten */
  1225.     write_opt("Iiii", 0, x, y);
  1226.  
  1227.     /* Lokales */
  1228.     for (i = 0; i < loc_opt_anz; i++)
  1229.     {
  1230.         lo = &loc_opt[i];
  1231.         opt = 0;
  1232.         if (lo->tab)                    opt += 1;
  1233.         if (lo->einruecken)            opt += 2;
  1234.         if (lo->umbrechen)             opt += 4;
  1235.         if (lo->format_by_load)     opt += 8;
  1236.         if (lo->format_by_paste)    opt += 16;
  1237.         if (lo->backup)                opt += 32;
  1238.         if (lo->show_end)                opt += 64;
  1239.         write_opt("Lsiiissss", muster_str[i], opt, lo->tabsize, lo->lineal_len,
  1240.                                         lo->umbruch_str,lo->wort_str, lo->kurzel, lo->backup_ext);
  1241.     }
  1242.  
  1243.     /* Marken */
  1244.     for (i = 0; i < 5; i++)
  1245.     {
  1246.         get_marke(i, name, file, &line, &x);
  1247.         if (file[0] != EOS)
  1248.             write_opt("Missli", i, name, file, line, x);
  1249.     }
  1250.  
  1251.     /* geladene Dateien */
  1252.     get_all_windows(NIL, SRCH_ANY, get_wind_data);
  1253.  
  1254.     /* Diverse Pfade und Texte */
  1255.     write_opt("Psssss", helpprog, error[0], def_prj_path, error[1], error[2]);
  1256.  
  1257.     /* Suchen/Ersetzen */
  1258.     opt = 0;
  1259.     if (s_round)        opt += 1;
  1260.     if (s_quant)        opt += 2;
  1261.     if (s_grkl)            opt += 4;
  1262.     if (s_runter)        opt += 8;
  1263.     if (s_global)        opt += 16;
  1264.     if (df_rekursiv)    opt += 32;
  1265.     if (s_wort)            opt += 64;
  1266.     write_opt("Riisssiiii", opt, r_modus, s_str, r_str, df_name, umlaut_from, 
  1267.                                     umlaut_to, rp_box_x, rp_box_y);
  1268.  
  1269.     /* SE-Protokol */
  1270.     for (i = 0; i < SHELLANZ - 1; i++)
  1271.     {
  1272.         if (se_shells[i].Name[0] != EOS)
  1273.             write_opt("Sisiis", i, se_shells[i].Name, se_autosave,
  1274.                                         se_autosearch, se_shells[i].Makefile);
  1275. /*
  1276.             write_opt("Sisiis", i, SE_Shells[i].Name, SE_Shells[i].aktiv,
  1277.                                         SE_Shells[i].start_comm, SE_Shells[i].Makefile);
  1278. */
  1279.     }
  1280.  
  1281.     /* Fenstergröße und Iconposition */
  1282.     d = -1;
  1283.     while(get_windinfo(&d, &i, &r, &opt, &opt2, &used))
  1284.         write_opt("Wiiiiiiii", i, r.x, r.y, r.w, r.h, opt, opt2, used);
  1285.  
  1286.     /* Zeichensätze */
  1287.     write_opt("Ziiii", winFont.ID, winFont.Size, druckFont.ID, druckFont.Size);
  1288.  
  1289.     /* Ring anpassen: Leerzeile vom init entfernen */
  1290.     col_delete(tmp_ring.head.nachf);
  1291.     tmp_ring.lines--;
  1292.  
  1293.     /* und wechschreiben */
  1294.     antw = save_datei(qed_path, &tmp_ring, FALSE, tos);
  1295.  
  1296.     kill_textring(&tmp_ring);
  1297.  
  1298.     return antw;
  1299. }
  1300.